home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Workbench Add-On
/
Workbench Add-On - Volume 1.iso
/
BBS-Archive
/
Comm
/
AmiTCP30b2.lha
/
src
/
amitcp
/
kern
/
amiga_cstat.c
< prev
next >
Wrap
C/C++ Source or Header
|
1994-02-03
|
15KB
|
576 lines
RCS_ID_C="$Id: amiga_cstat.c,v 3.1 1994/02/03 03:59:36 ppessi Exp $";
/*
* Copyright (c) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
* Helsinki University of Technology, Finland.
* All rights reserved.
*
* HISTORY
* $Log: amiga_cstat.c,v $
* Revision 3.1 1994/02/03 03:59:36 ppessi
* Changed the format of network interface names
*
* Revision 1.23 1994/01/18 02:29:17 jraja
* Added rexx_gethostname() and rexx_sethostname() functions.
*
* Revision 1.22 1993/12/31 01:23:24 ppessi
* Fixed netmask handling.
*
* Revision 1.21 1993/11/06 23:51:22 ppessi
* Added Berkeley licence. Added route tree printing routines.
* Changed some allocation routines.
*
*/
/*
* Copyright (c) 1983, 1988 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <conf.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/synch.h>
#include <sys/malloc.h>
#include <sys/syslog.h>
#include <kern/amiga_includes.h>
#include <kern/amiga_rexx.h>
#include <kern/amiga_config.h>
#include <dos/rdargs.h>
#if __SASC
#include <proto/dos.h>
#elif __GNUC__
#include <inline/dos.h>
#endif
#include <net/route.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/in_pcb.h>
#include <netinet/ip_var.h>
#include <netinet/ip_icmp.h>
#include <netinet/icmp_var.h>
#include <netinet/tcp.h>
#include <netinet/tcp_timer.h>
#include <netinet/tcp_var.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <api/apicalls.h>
long count = 0;
int
ultoa(unsigned long ul,char *buffer)
{
static char buf[10];
char *p;
int len;
p = buf;
*p='\0';
do {
*++p = (ul % 10)+'0';
} while (ul /= 10);
len = p - buf;
while (*buffer++ = *p--)
;
return(len);
}
int
ltoa(long l, char *buffer)
{
int len=0;
if(l<0){
*buffer++='-';
l=-l;
len++;
}
return (len + ultoa((unsigned long)l, buffer));
}
/*
* Allocate big enough buffer for reply
*/
LONG
CS_Alloc(struct CSource *reply, size_t size)
{
/* do we have enough space? */
if (reply->CS_Length < size) {
char *buffer;
if ((buffer = bsd_malloc(size, M_TEMP, 0)) == NULL){
return 0;
}
/*
* Old buffer will be freed by caller
*/
reply->CS_Buffer = buffer;
reply->CS_Length = size;
}
return 1;
}
/*
* getsockets(): a reply statics for all sockets
*
*/
struct printsocket {
struct in_addr inp_faddr; /* u_long, far addr */
u_short inp_fport;
struct in_addr inp_laddr; /* u_long, local addr */
u_short inp_lport;
short so_type; /* SOCK_STREAM, _DGRAM... */
u_short so_rcv_sb_cc; /* Recv queue size */
u_short so_snd_sb_cc; /* Send queue */
short inp_ppcb_t_state; /* State of TCP connection */
};
LONG
getsockets(struct CSource *args, UBYTE **errstrp, struct CSource *res)
{
int i, count = 0;
struct inpcb *pcb;
struct printsocket *pps, *mem;
spl_t s = splnet(); /* Critical section starts here */
/* Count number of connections */
for(pcb = udb.inp_next; pcb != &udb ; pcb = pcb->inp_next)
++count;
for(pcb = tcb.inp_next; pcb != &tcb ; pcb = pcb->inp_next)
++count;
if (count == 0) { /* return now if nothing to print */
splx(s);
return RETURN_OK;
}
/* Allocate memory */
mem = (struct printsocket *)
bsd_malloc(sizeof(struct printsocket) * (count), M_TEMP, 0);
if (mem == NULL) {
splx(s);
*errstrp = ERR_MEMORY;
return RETURN_FAIL;
}
/* Proto recv-q send-q laddr lport faddr fport state */
/* 1 1 4 1 4 1 8 1 4 1 8 1 4 1 1 1 = 42 chars */
#define STATLEN 42
if (!CS_Alloc(res, STATLEN * count + 1)) {
/* Allocation failed, free printsocket memory */
splx(s);
bsd_free(mem, M_TEMP);
*errstrp = ERR_MEMORY;
return RETURN_FAIL;
}
/* Copy information, TCP first.. */
for(pcb = tcb.inp_next, pps = mem; pcb != &tcb; pcb = pcb->inp_next, ++pps){
pps->inp_faddr = pcb->inp_faddr;
pps->inp_fport = pcb->inp_fport;
pps->inp_laddr = pcb->inp_laddr;
pps->inp_lport = pcb->inp_lport;
pps->so_type = pcb->inp_socket->so_type;
pps->so_rcv_sb_cc = pcb->inp_socket->so_rcv.sb_cc;
pps->so_snd_sb_cc = pcb->inp_socket->so_snd.sb_cc;
pps->inp_ppcb_t_state = ((struct tcpcb *)(pcb->inp_ppcb))->t_state;
}
/* ...then UDP */
for(pcb = udb.inp_next; pcb != &udb; pcb = pcb->inp_next, ++pps){
pps->inp_faddr = pcb->inp_faddr;
pps->inp_fport = pcb->inp_fport;
pps->inp_laddr = pcb->inp_laddr;
pps->inp_lport = pcb->inp_lport;
pps->so_type = pcb->inp_socket->so_type;
pps->so_rcv_sb_cc = pcb->inp_socket->so_rcv.sb_cc;
pps->so_snd_sb_cc = pcb->inp_socket->so_snd.sb_cc;
pps->inp_ppcb_t_state = 0; /* NO state for UDP */
}
splx(s); /* Critical section completed now */
/*
* Print all socket entries
*/
for(i = 0; i < count; i++)
csprintf(res, "%lc %04lx %04lx %08lx %04lx %08lx %04lx %1lx%s",
mem[i].so_type == SOCK_STREAM ? 't': 'u',
mem[i].so_rcv_sb_cc, mem[i].so_snd_sb_cc,
mem[i].inp_laddr.s_addr, mem[i].inp_lport,
mem[i].inp_faddr.s_addr, mem[i].inp_fport,
mem[i].inp_ppcb_t_state,
(i < count - 1) ? " " : "");
#if DIAGNOSTIC /* check for overrun */
if (res->CS_CurChr >= res->CS_Length)
log(LOG_ERR, "getsockets(): buffer overwritten by %ld bytes\n",
res->CS_CurChr - res->CS_Length + 1);
#endif
/*
* free mem
*/
bsd_free(mem, M_TEMP);
return RETURN_OK;
}
/*
* Get ICMP history profiles
*/
#include <netinet/icmp_var.h>
#include <netinet/ip_icmp.h>
LONG
read_icmphist(struct CSource *args, UBYTE **errstrp, struct CSource *res)
{
int i;
UBYTE *p = res->CS_Buffer;
for(i = 0;i <= ICMP_MAXTYPE; i++){
p += ultoa(icmpstat.icps_outhist[i], p);
*p++=' ';
}
for(i = 0;i <= ICMP_MAXTYPE; i++){
p += ultoa(icmpstat.icps_inhist[i], p);
*p++ = ' ';
}
*--p = '\0';
res->CS_CurChr = p - res->CS_Buffer;
return RETURN_OK;
}
/*
* Get routing tables
*/
#include <net/route.h>
#include <net/if.h>
#define DB(x) ;
/* Address families supported */
extern STRPTR KW_Protocols;
/* What is stored in the route entry */
#define NORMAL 0
#define MASK 1
#define DUPED 2
/* Our recursion depth in route tree. 32 is # of bits in IP address */
/* Other protocols may require deeper stack */
#define MAX_ROUTE_TREE_DEPTH 32
struct printroute {
struct sockaddr pr_dest;
struct sockaddr pr_via;
u_long pr_use;
struct ifnet *pr_ifp;
short pr_refcnt;
u_short pr_flags;
u_short pr_what;
};
static void cstat_rtentry(struct rtentry *rt, struct printroute *pr);
static void cstat_maskentry(struct radix_node *rn, struct printroute *pr);
static int cstat_rtree(struct radix_node *rn, struct printroute *pr, int);
static void cstat_rtflags(struct CSource *, const char *, register int);
LONG
getroutes(struct CSource *args, UBYTE **errstrp, struct CSource *res)
{
UBYTE Buffer[KEYWORDLEN];
int af, newroutes, routes = 0;
struct radix_node_head *rnh;
struct printroute *mem, *pr;
spl_t s;
/*
* Parse address family
*
* Match the against the template. The af is the index of
* the matching keyword, if one is found.
*/
if (ReadItem(Buffer, sizeof(Buffer), args) <= 0) {
*errstrp = ERR_SYNTAX;
return RETURN_ERROR;
}
if ((af = FindArg(KW_Protocols, Buffer)) < 0) {
res->CS_CurChr = 0;
csprintf(res, ERR_ILLEGAL_VAR, "getroutes", Buffer);
*errstrp = res->CS_Buffer;
return RETURN_WARN;
}
DB(log(LOG_DEBUG, "getroutes: getting routes for protocol %s (%ld)",
Buffer, af));
s = splnet(); /* Critical section */
/* Count entries in tables */
for (rnh = radix_node_head; rnh ; rnh = rnh->rnh_next) {
if (af == AF_UNSPEC || af == rnh->rnh_af) {
newroutes = cstat_rtree(rnh->rnh_treetop, NULL, rnh->rnh_af != AF_UNSPEC);
if (newroutes < 0) {
splx(s);
*errstrp = (UBYTE *)"Route tree overflow.\n";
return RETURN_FAIL;
}
routes += newroutes;
}
}
DB(log(LOG_DEBUG, "getroutes: found %ld routes", routes));
/* Allocate memory for entries */
pr = mem = (struct printroute *)
bsd_malloc(sizeof(struct printroute) * (routes), M_TEMP, 0);
if (mem == NULL) {
splx(s);
*errstrp = ERR_MEMORY;
return RETURN_FAIL;
}
/* Fill in printroute table */
for (rnh = radix_node_head; rnh ; rnh = rnh->rnh_next) {
if (af == AF_UNSPEC || af == rnh->rnh_af) {
pr += cstat_rtree(rnh->rnh_treetop, pr, rnh->rnh_af != AF_UNSPEC);
#if DIAGNOSTIC
if (pr > mem + routes) {
const UBYTE *msg = "cstat_rtree(): found more entries than counted!\n";
splx(s);
bsd_free(mem, M_TEMP);
log(LOG_ERR, msg);
*errstrp = (UBYTE *)msg;
return RETURN_FAIL;
}
#endif
}
}
splx(s); /* End of critical section */
/* Reply line has format
* protocol route gateway flags refcount used device/unit + separation
* 2 + 8 + 8 + 4 + 4 + 8 + 32 + 10 + 10 = 90 chars
*/
if (!CS_Alloc(res, 90 * routes)) {
/* Allocation failed, free printroute memory */
bsd_free(mem, M_TEMP);
*errstrp = ERR_MEMORY;
return RETURN_FAIL;
}
/* cstat_rtree_print */
for (pr = mem; routes-- > 0 ; pr++) {
csprintf(res, "%02lx %08lx %08lx ",
pr->pr_dest.sa_family,
((struct sockaddr_in *)&pr->pr_dest)->sin_addr.s_addr,
((struct sockaddr_in *)&pr->pr_via)->sin_addr.s_addr);
cstat_rtflags(res, "%-8.8s ", pr->pr_flags);
csprintf(res, "%04lx %08lx ", pr->pr_refcnt, pr->pr_use);
if (pr->pr_ifp) {
csprintf(res, "%s%ld ", pr->pr_ifp->if_name, pr->pr_ifp->if_unit);
} else {
csprintf(res, "none ");
}
}
/* free printsocket structures */
bsd_free(mem, M_TEMP);
return RETURN_OK;
}
/*
* cstat_rtree(): get a route tree to a table
*/
static int
cstat_rtree(struct radix_node *rn, struct printroute *pr, int do_rtent)
{
short routes = 0;
short stack_pointer = 0;
struct radix_node *stack[MAX_ROUTE_TREE_DEPTH];
again:
if (rn->rn_b < 0) {
if ((rn->rn_flags & RNF_ROOT) == 0) {
if (pr) {
if (do_rtent)
cstat_rtentry((struct rtentry*)rn, pr);
else
cstat_maskentry(rn, pr);
pr++;
}
routes++;
}
if (rn = rn->rn_dupedkey)
goto again;
} else {
if (rn->rn_r) {
if (stack_pointer >= MAX_ROUTE_TREE_DEPTH - 1)
return -1;
stack[stack_pointer++] = rn->rn_r;
}
/* tail recursion removal */
if (rn = rn->rn_l) {
goto again;
}
}
/* recursion removal */
if (stack_pointer-- > 0) {
rn = stack[stack_pointer];
goto again;
}
DB(log(LOG_DEBUG, "rtree: found %ld routes", routes));
return routes;
}
/*
* Copy rtentry into printroute
* assumes that rtentry and pr are valid
*/
static void
cstat_rtentry(struct rtentry *rt, struct printroute *pr)
{
/* These should allow variable sized sockaddrs */
bcopy(rt_key(rt), &pr->pr_dest, sizeof(pr->pr_dest));
bcopy(rt->rt_gateway, &pr->pr_via, sizeof(pr->pr_via));
/* */
pr->pr_use = rt->rt_use;
pr->pr_refcnt = rt->rt_refcnt;
pr->pr_ifp = rt->rt_ifp;
pr->pr_flags = rt->rt_flags;
if (rt->rt_nodes->rn_dupedkey)
pr->pr_what = DUPED;
else
pr->pr_what = NORMAL;
}
/*
* Copy netmask into printroute
* assumes that rn and pr are valid
*/
static void
cstat_maskentry(struct radix_node *rn, struct printroute *pr)
{
/* These should allow variable sized sockaddrs */
bcopy((struct sockaddr *)rn->rn_key, &pr->pr_dest, sizeof(pr->pr_dest));
bzero(&pr->pr_via, sizeof(pr->pr_via));
pr->pr_use = 0;
pr->pr_refcnt = 0;
pr->pr_ifp = NULL;
pr->pr_flags = 0;
pr->pr_what = MASK;
}
/*
* Definitions for showing gateway flags.
*/
struct bits {
short b_mask;
char b_val;
} bits[] = {
{ RTF_UP, 'U' },
{ RTF_GATEWAY, 'G' },
{ RTF_HOST, 'H' },
{ RTF_DYNAMIC, 'D' },
{ RTF_MODIFIED, 'M' },
{ RTF_CLONING, 'C' },
{ RTF_XRESOLVE, 'X' },
{ RTF_LLINFO, 'L' },
{ RTF_REJECT, 'R' },
{ 0 }
};
static void
cstat_rtflags(struct CSource *res, const char *format, register int f)
{
char name[33], *flags;
register struct bits *p = bits;
for (flags = name; p->b_mask; p++)
if (p->b_mask & f)
*flags++ = p->b_val;
*flags = '\0';
if (name[0] != '\0') {
csprintf(res, format, name);
} else {
/* Empty string may confuse parsers */
csprintf(res, format, "\"\"");
}
}
extern char *host_name;
extern size_t host_namelen;
extern int sethostname(const char * name, size_t namelen);
extern struct Library *SocketBase; /* base opened by NETTRACE */
LONG
rexx_gethostname(struct CSource *args, UBYTE **errstrp, struct CSource *res)
{
gethostname((struct SocketBase *)SocketBase, CURRENT(res), SPACE(res));
res->CS_CurChr += strlen(CURRENT(res));
return RETURN_OK;
}
LONG
rexx_sethostname(struct CSource *args, UBYTE **errstrp, struct CSource *res)
{
char Buffer[MAXHOSTNAMELEN+1];
if (ReadItem(Buffer, sizeof(Buffer), args) <= 0) {
*errstrp = ERR_SYNTAX;
return RETURN_ERROR;
}
sethostname(Buffer, sizeof(Buffer));
return RETURN_OK;
}